Local Driving in Higher-Order Positive Supercompilation via the Ω-theorem

A program transformation technique should terminate, return efficient output programs and be efficient itself. These requirements are mutually conflicting, so a balance must be sought between definite termination and possible efficiency. For positive supercompilation [17], ensuring termination requires memoisation of expressions, and these are subsequently used to determine when to perform generalization and folding [16]. For a first-order language, every infinite sequence of transformation steps must include function unfolding, so it is sufficient to memoise only those expressions immediately prior to a function unfolding step. However, for a higher-order language, it is possible for an expression to have an infinite sequence of transformation steps which do not include function unfolding, so memoisation prior to a function unfolding step is not sufficient by itself to ensure termination. But memoising additional expressions is expensive during transformation and may lead to less efficient output programs due to auxiliary functions. This additional memoisation may happen explicitly during transformation or implicitly via a pre-processing transformation as outlined in previous work by the first author [5]. We introduce a new technique for local driving in higher-order positive supercompilation which obliviates the need for memoising other expressions than function unfolding steps, thereby improving efficiency of both the transformation and the generated programs. We exploit the fact, due to the second author in the setting of type-free λ-calculus [20] known as the Ω-theorem, that every expression with an infinite sequence of transformation steps not involving function unfolding must have the term Ω = (λx.x x) (λx.x x) embedded within it in a certain sense. The technique has proven useful on a host of examples.